/**
 * 咖啡机服务
 * 负责与以勒咖啡机SDK通信
 */

// 判断环境中是否存在window对象和plus对象
const hasWindow = typeof window !== 'undefined';
const hasPlusObject = hasWindow && typeof window.plus !== 'undefined';

// 咖啡机服务类
class CoffeeService {
    constructor() {
        this.isInitialized = false;
        this.connectedDevice = null;
        this.listeners = {
            statusChange: [],
            brewingProgress: [],
            connectionChange: []
        };
    }
    
    // 初始化服务
    async init() {
        if (!this.isInitialized) {
            try {
                console.log('初始化咖啡机SDK');
                // 通过plus.bridge调用原生方法初始化SDK
                if (hasWindow && window.plus && window.plus.bridge) {
                    try {
                        const result = window.plus.bridge.exec('CoffeeMachineModule', 'initSDK', []);
                        console.log('SDK初始化结果:', result);
                    } catch (e) {
                        console.error('SDK初始化失败:', e);
                        return false;
                    }
                }
                
                this.isInitialized = true;
                return true;
            } catch (error) {
                console.error('初始化咖啡机SDK失败:', error);
                this.isInitialized = false;
                return false;
            }
        }
        return this.isInitialized;
    }
    
    // 搜索咖啡机
    async scanDevices() {
        await this.init();
        
        return new Promise((resolve, reject) => {
            if (hasWindow && window.plus && window.plus.bridge) {
                try {
                    window.plus.bridge.exec('CoffeeMachineModule', 'scanDevices', [], (devices) => {
                        resolve(devices || []);
                    });
                } catch (e) {
                    console.error('扫描设备失败:', e);
                    // 失败时返回空数组
                    resolve([]);
                }
            } else {
                // 在非原生环境中模拟
                setTimeout(() => {
                    resolve([
                        { id: '/dev/ttyS0', name: '咖啡机LE308G', rssi: -45 },
                        { id: '/dev/ttyS1', name: '咖啡机LE308G', rssi: -60 }
                    ]);
                }, 2000);
            }
        });
    }
    
    // 连接到咖啡机
    async connect(deviceId) {
        await this.init();
        
        try {
            let result = false;
            
            if (hasWindow && window.plus && window.plus.bridge) {
                result = window.plus.bridge.exec('CoffeeMachineModule', 'connect', [deviceId, 38400, 0]);
            } else {
                // 非原生环境模拟成功
                result = true;
            }
            
            if (result) {
                this.connectedDevice = deviceId;
                
                // 开始状态监听
                if (hasWindow && window.plus) {
                    this._startStateListener();
                }
                
                // 通知连接状态变化
                this._notifyConnectionChange(true);
            }
            
            return result;
        } catch (error) {
            console.error('连接设备失败:', error);
            return false;
        }
    }
    
    // 断开连接
    async disconnect() {
        if (!this.connectedDevice) {
            return true;
        }
        
        try {
            let result = false;
            
            if (hasWindow && window.plus && window.plus.bridge) {
                // 停止状态监听
                this._stopStateListener();
                
                // 调用原生断开连接
                result = window.plus.bridge.exec('CoffeeMachineModule', 'disconnect', []);
            } else {
                // 非原生环境模拟成功
                result = true;
            }
            
            if (result) {
                this.connectedDevice = null;
                
                // 通知连接状态变化
                this._notifyConnectionChange(false);
            }
            
            return result;
        } catch (error) {
            console.error('断开设备连接失败:', error);
            return false;
        }
    }
    
    // 获取咖啡机状态
    async getStatus() {
        if (!this.connectedDevice) {
            throw new Error('咖啡机未连接');
        }
        
        return new Promise((resolve, reject) => {
            if (hasWindow && window.plus && window.plus.bridge) {
                try {
                    const status = window.plus.bridge.exec('CoffeeMachineModule', 'getStatus', []);
                    resolve(status || {
                        waterLevel: 80,
                        beanLevel: 90,
                        temperature: 95,
                        error: null
                    });
                } catch (e) {
                    console.error('获取状态失败:', e);
                    reject(new Error('获取咖啡机状态失败'));
                }
            } else {
                // 非原生环境模拟数据
                resolve({
                    waterLevel: 80,
                    beanLevel: 90,
                    temperature: 95,
                    error: null
                });
            }
        });
    }
    
    // 制作咖啡
    async brewCoffee(params) {
        if (!this.connectedDevice) {
            throw new Error('咖啡机未连接');
        }
        
        const { type, temperature, strength, waterAmount } = params;
        
        return new Promise((resolve, reject) => {
            if (hasWindow && window.plus && window.plus.bridge) {
                try {
                    window.plus.bridge.exec('CoffeeMachineModule', 'brewCoffee', [{
                        type, temperature, strength, waterAmount
                    }], (result) => {
                        if (result && result.success) {
                            resolve(result);
                        } else {
                            reject(new Error('制作咖啡失败'));
                        }
                    });
                } catch (e) {
                    console.error('制作咖啡失败:', e);
                    reject(new Error('制作咖啡失败'));
                }
            } else {
                // 非原生环境模拟制作过程
                setTimeout(() => {
                    resolve({ success: true });
                }, 5000);
            }
        });
    }
    
    // 停止制作
    async stopBrewing() {
        if (!this.connectedDevice) {
            return true;
        }
        
        try {
            if (hasWindow && window.plus && window.plus.bridge) {
                return window.plus.bridge.exec('CoffeeMachineModule', 'stopBrewing', []);
            }
            return true;
        } catch (error) {
            console.error('停止制作咖啡失败:', error);
            return false;
        }
    }
    
    // 获取制作进度
    async getBrewingProgress() {
        if (!this.connectedDevice) {
            throw new Error('咖啡机未连接');
        }
        
        return new Promise((resolve, reject) => {
            if (hasWindow && window.plus && window.plus.bridge) {
                try {
                    const progress = window.plus.bridge.exec('CoffeeMachineModule', 'getBrewingProgress', []);
                    resolve(progress || {
                        progress: 0,
                        status: 'idle',
                        remaining: 0
                    });
                } catch (e) {
                    console.error('获取进度失败:', e);
                    reject(new Error('获取制作进度失败'));
                }
            } else {
                // 非原生环境模拟进度
                resolve({
                    progress: 65,
                    status: 'brewing',
                    remaining: 35
                });
            }
        });
    }
    
    // 设置机器参数
    async setMachineSettings(settings) {
        if (!this.connectedDevice) {
            throw new Error('咖啡机未连接');
        }
        
        try {
            if (hasWindow && window.plus && window.plus.bridge) {
                return window.plus.bridge.exec('CoffeeMachineModule', 'setMachineSettings', [settings]);
            }
            return true;
        } catch (error) {
            console.error('设置机器参数失败:', error);
            return false;
        }
    }
    
    // 添加状态变化监听器
    addStatusChangeListener(listener) {
        this.listeners.statusChange.push(listener);
    }
    
    // 移除状态变化监听器
    removeStatusChangeListener(listener) {
        if (listener) {
            const index = this.listeners.statusChange.indexOf(listener);
            if (index !== -1) {
                this.listeners.statusChange.splice(index, 1);
            }
        } else {
            // 如果没有指定监听器，清空所有
            this.listeners.statusChange = [];
        }
    }
    
    // 添加制作进度监听器
    addBrewingProgressListener(listener) {
        this.listeners.brewingProgress.push(listener);
    }
    
    // 移除制作进度监听器
    removeBrewingProgressListener(listener) {
        if (listener) {
            const index = this.listeners.brewingProgress.indexOf(listener);
            if (index !== -1) {
                this.listeners.brewingProgress.splice(index, 1);
            }
        } else {
            // 如果没有指定监听器，清空所有
            this.listeners.brewingProgress = [];
        }
    }
    
    // 添加连接状态变化监听器
    addConnectionChangeListener(listener) {
        this.listeners.connectionChange.push(listener);
    }
    
    // 移除连接状态变化监听器
    removeConnectionChangeListener(listener) {
        if (listener) {
            const index = this.listeners.connectionChange.indexOf(listener);
            if (index !== -1) {
                this.listeners.connectionChange.splice(index, 1);
            }
        } else {
            // 如果没有指定监听器，清空所有
            this.listeners.connectionChange = [];
        }
    }
    
    // 开始咖啡机状态监听
    _startStateListener() {
        if (hasWindow && window.plus && window.plus.bridge) {
            // 注册状态变化监听器
            window.plus.bridge.exec('CoffeeMachineModule', 'registerStateListener', []);
            
            // 设置状态回调方法 (需在原生模块中调用window.coffeeStateCallback)
            window.coffeeStateCallback = (state) => {
                this._notifyStatusChange(state);
            };
            
            // 设置进度回调方法
            window.coffeeProgressCallback = (progress) => {
                this.listeners.brewingProgress.forEach(listener => {
                    try {
                        listener(progress);
                    } catch (error) {
                        console.error('进度监听器执行出错:', error);
                    }
                });
            };
        }
    }
    
    // 停止咖啡机状态监听
    _stopStateListener() {
        if (hasWindow && window.plus && window.plus.bridge) {
            window.plus.bridge.exec('CoffeeMachineModule', 'unregisterStateListener', []);
            
            // 清理回调
            if (hasWindow) {
                window.coffeeStateCallback = null;
                window.coffeeProgressCallback = null;
            }
        }
    }
    
    // 通知状态变化
    _notifyStatusChange(state) {
        const status = {
            waterLevel: state?.waterLevel || 0,
            beanLevel: state?.beanLevel || 0,
            temperature: state?.temperature || 0,
            error: state?.error || null
        };
        
        this.listeners.statusChange.forEach(listener => {
            try {
                listener(status);
            } catch (error) {
                console.error('状态变化监听器执行出错:', error);
            }
        });
    }
    
    // 通知连接状态变化
    _notifyConnectionChange(connected) {
        this.listeners.connectionChange.forEach(listener => {
            try {
                listener(connected);
            } catch (error) {
                console.error('连接状态变化监听器执行出错:', error);
            }
        });
    }
}

// 导出单例实例
export default new CoffeeService(); 